#!/usr/bin/env node

/**
 * 开发环境快速启动脚本
 * 用于快速启动前端开发服务器并检查后端连接
 */

const { spawn, exec } = require('child_process')
const path = require('path')
const fs = require('fs')

// 颜色输出
const colors = {
  reset: '\x1b[0m',
  bright: '\x1b[1m',
  red: '\x1b[31m',
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  blue: '\x1b[34m',
  magenta: '\x1b[35m',
  cyan: '\x1b[36m'
}

function log(message, color = 'reset') {
  console.log(`${colors[color]}${message}${colors.reset}`)
}

function logStep(step, message) {
  log(`[${step}] ${message}`, 'cyan')
}

function logSuccess(message) {
  log(`✅ ${message}`, 'green')
}

function logError(message) {
  log(`❌ ${message}`, 'red')
}

function logWarning(message) {
  log(`⚠️  ${message}`, 'yellow')
}

// 检查端口是否被占用
function checkPort(port) {
  return new Promise((resolve) => {
    const net = require('net')
    const server = net.createServer()
    
    server.listen(port, () => {
      server.once('close', () => {
        resolve(false) // 端口可用
      })
      server.close()
    })
    
    server.on('error', () => {
      resolve(true) // 端口被占用
    })
  })
}

// 检查后端服务
async function checkBackendService() {
  return new Promise((resolve) => {
    const http = require('http')
    const options = {
      hostname: 'localhost',
      port: 8080,
      path: '/api/health',
      method: 'GET',
      timeout: 3000
    }

    const req = http.request(options, (res) => {
      resolve(res.statusCode === 200)
    })

    req.on('error', () => {
      resolve(false)
    })

    req.on('timeout', () => {
      req.destroy()
      resolve(false)
    })

    req.end()
  })
}

// 检查MySQL服务
async function checkMySQLService() {
  return new Promise((resolve) => {
    exec('mysql --version', (error) => {
      if (error) {
        resolve(false)
      } else {
        // 尝试连接MySQL
        exec('mysql -u root -e "SELECT 1" 2>/dev/null', (error) => {
          resolve(!error)
        })
      }
    })
  })
}

// 检查Redis服务
async function checkRedisService() {
  return new Promise((resolve) => {
    exec('redis-cli ping', (error, stdout) => {
      resolve(!error && stdout.trim() === 'PONG')
    })
  })
}

// 检查环境配置
function checkEnvironmentConfig() {
  const envFile = path.join(__dirname, '../.env.development')
  if (!fs.existsSync(envFile)) {
    logError('环境配置文件 .env.development 不存在')
    return false
  }
  
  const envContent = fs.readFileSync(envFile, 'utf8')
  const requiredVars = [
    'VITE_APP_BASE_API',
    'VITE_APP_TITLE'
  ]
  
  for (const varName of requiredVars) {
    if (!envContent.includes(varName)) {
      logError(`环境变量 ${varName} 未配置`)
      return false
    }
  }
  
  return true
}

// 主函数
async function main() {
  log('🚀 洗护服务商户端开发环境启动脚本', 'bright')
  log('=' .repeat(50), 'blue')
  
  // 1. 检查环境配置
  logStep('1', '检查环境配置...')
  if (!checkEnvironmentConfig()) {
    logError('环境配置检查失败，请检查 .env.development 文件')
    process.exit(1)
  }
  logSuccess('环境配置检查通过')
  
  // 2. 检查端口占用
  logStep('2', '检查端口占用...')
  const frontendPortBusy = await checkPort(5173)
  const backendPortBusy = await checkPort(8080)
  
  if (frontendPortBusy) {
    logWarning('前端端口 5173 已被占用')
  } else {
    logSuccess('前端端口 5173 可用')
  }
  
  if (backendPortBusy) {
    logSuccess('后端端口 8080 已被占用（后端服务可能已启动）')
  } else {
    logWarning('后端端口 8080 未被占用（后端服务可能未启动）')
  }
  
  // 3. 检查依赖服务
  logStep('3', '检查依赖服务...')
  
  const mysqlRunning = await checkMySQLService()
  if (mysqlRunning) {
    logSuccess('MySQL 服务正常')
  } else {
    logWarning('MySQL 服务未运行或无法连接')
  }
  
  const redisRunning = await checkRedisService()
  if (redisRunning) {
    logSuccess('Redis 服务正常')
  } else {
    logWarning('Redis 服务未运行')
  }
  
  // 4. 检查后端服务
  logStep('4', '检查后端服务...')
  const backendRunning = await checkBackendService()
  if (backendRunning) {
    logSuccess('Spring Boot 后端服务正常')
  } else {
    logWarning('Spring Boot 后端服务未运行')
    log('请启动后端服务：', 'yellow')
    log('  cd ../backend', 'yellow')
    log('  mvn spring-boot:run', 'yellow')
  }
  
  // 5. 启动前端开发服务器
  logStep('5', '启动前端开发服务器...')
  
  if (frontendPortBusy) {
    logWarning('前端服务器可能已经在运行')
    log('如果需要重启，请先停止现有服务器', 'yellow')
  } else {
    log('正在启动前端开发服务器...', 'cyan')
    
    const viteProcess = spawn('npm', ['run', 'dev'], {
      cwd: path.join(__dirname, '..'),
      stdio: 'inherit',
      shell: true
    })
    
    viteProcess.on('error', (error) => {
      logError(`启动前端服务器失败: ${error.message}`)
    })
    
    // 等待一段时间后显示访问信息
    setTimeout(() => {
      log('=' .repeat(50), 'blue')
      logSuccess('前端开发服务器启动完成')
      log('📱 前端访问地址:', 'bright')
      log('  - 主应用: http://localhost:5173', 'green')
      log('  - 后端测试: http://localhost:5173/backend-test', 'green')
      log('  - API测试: http://localhost:5173/api-test', 'green')
      
      if (backendRunning) {
        log('🔗 后端服务地址:', 'bright')
        log('  - API接口: http://localhost:8080/api', 'green')
        log('  - 健康检查: http://localhost:8080/api/health', 'green')
      }
      
      log('🛠️  开发工具:', 'bright')
      log('  - 按 Ctrl+C 停止服务器', 'yellow')
      log('  - 修改代码会自动热重载', 'yellow')
      log('  - 查看浏览器控制台获取详细信息', 'yellow')
      log('=' .repeat(50), 'blue')
    }, 3000)
  }
  
  // 处理退出信号
  process.on('SIGINT', () => {
    log('\n正在停止开发服务器...', 'yellow')
    process.exit(0)
  })
}

// 运行主函数
main().catch((error) => {
  logError(`启动失败: ${error.message}`)
  process.exit(1)
})
